diff --git a/parquet/src/encryption/ciphers.rs b/parquet/src/encryption/ciphers.rs
index 89515fe0e..fc0b703ba 100644
--- a/parquet/src/encryption/ciphers.rs
+++ b/parquet/src/encryption/ciphers.rs
@@ -194,7 +194,7 @@ fn create_module_aad(file_aad: &[u8], module_type: ModuleType, row_group_ordinal
     }
     if row_group_ordinal > i16::MAX {
         return Err(general_err!("Encrypted parquet files can't have more than {} row groups: {}",
-            u16::MAX, row_group_ordinal));
+            i16::MAX, row_group_ordinal));
     }
 
     if column_ordinal < 0 {
@@ -202,7 +202,7 @@ fn create_module_aad(file_aad: &[u8], module_type: ModuleType, row_group_ordinal
     }
     if column_ordinal > i16::MAX {
         return Err(general_err!("Encrypted parquet files can't have more than {} columns: {}",
-            u16::MAX, column_ordinal));
+            i16::MAX, column_ordinal));
     }
 
     if module_buf[0] != (ModuleType::DataPageHeader as u8) &&
@@ -218,10 +218,11 @@ fn create_module_aad(file_aad: &[u8], module_type: ModuleType, row_group_ordinal
     if page_ordinal < 0 {
         return Err(general_err!("Wrong page ordinal: {}", page_ordinal));
     }
-    if page_ordinal > i32::MAX {
+    if page_ordinal > (i16::MAX as i32){
         return Err(general_err!("Encrypted parquet files can't have more than {} pages in a chunk: {}",
-            u16::MAX, page_ordinal));
+            i16::MAX, page_ordinal));
     }
+    let page_ordinal = page_ordinal as i16;
 
     let mut aad = Vec::with_capacity(file_aad.len() + 7);
     aad.extend_from_slice(file_aad);
diff --git a/parquet/src/file/serialized_reader.rs b/parquet/src/file/serialized_reader.rs
index adf4aa07a..48796b09f 100644
--- a/parquet/src/file/serialized_reader.rs
+++ b/parquet/src/file/serialized_reader.rs
@@ -342,7 +342,6 @@ impl<R: 'static + ChunkReader> RowGroupReader for SerializedRowGroupReader<'_, R
 
 /// Reads a [`PageHeader`] from the provided [`Read`]
 pub(crate) fn read_page_header<T: Read>(input: &mut T, crypto_context: Option<Arc<CryptoContext>>) -> Result<PageHeader> {
-    let mut prot = TCompactInputProtocol::new(input);
     if let Some(crypto_context) = crypto_context {
         // let mut buf = [0; 16 * 1024];
         // let size = input.read(&mut buf)?;
@@ -354,19 +353,25 @@ pub(crate) fn read_page_header<T: Read>(input: &mut T, crypto_context: Option<Ar
 
         let aad = create_page_aad(
             aad_file_unique.as_slice(),
-            ModuleType::DictionaryPageHeader,
+            ModuleType::DataPageHeader,
             crypto_context.row_group_ordinal,
             crypto_context.column_ordinal,
             0,
         )?;
 
-        // todo: This currently fails, possibly due to wrongly generated AAD
-        let buf = file_decryptor.decrypt(prot.read_bytes()?.as_slice(), aad.as_ref());
+        let mut len_bytes = [0; 4];
+        input.read_exact(&mut len_bytes)?;
+        let ciphertext_len = u32::from_le_bytes(len_bytes) as usize;
+        let mut ciphertext = vec![0; 4 + ciphertext_len];
+        input.read_exact(&mut ciphertext[4..])?;
+        let buf = file_decryptor.decrypt(&ciphertext, aad.as_ref());
         todo!("Decrypted page header!");
         let mut prot = TCompactSliceInputProtocol::new(buf.as_slice());
         let page_header = PageHeader::read_from_in_protocol(&mut prot)?;
         return Ok(page_header)
     }
+
+    let mut prot = TCompactInputProtocol::new(input);
     let page_header = PageHeader::read_from_in_protocol(&mut prot)?;
     Ok(page_header)
 }